home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 11 / Cream of the Crop 11-1.iso / compress / gnucpio.zip / RTAPELIB.C < prev    next >
C/C++ Source or Header  |  1994-11-30  |  14KB  |  583 lines
  1. /* Functions for communicating with a remote tape drive.
  2.    Copyright (C) 1988, 1992 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify
  5.    it under the terms of the GNU General Public License as published by
  6.    the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.    GNU General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU General Public License
  15.    along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17.  
  18. /* The man page rmt(8) for /etc/rmt documents the remote mag tape
  19.    protocol which rdump and rrestore use.  Unfortunately, the man
  20.    page is *WRONG*.  The author of the routines I'm including originally
  21.    wrote his code just based on the man page, and it didn't work, so he
  22.    went to the rdump source to figure out why.  The only thing he had to
  23.    change was to check for the 'F' return code in addition to the 'E',
  24.    and to separate the various arguments with \n instead of a space.  I
  25.    personally don't think that this is much of a problem, but I wanted to
  26.    point it out. -- Arnold Robbins
  27.  
  28.    Originally written by Jeff Lee, modified some by Arnold Robbins.
  29.    Redone as a library that can replace open, read, write, etc., by
  30.    Fred Fish, with some additional work by Arnold Robbins.
  31.    Modified to make all rmtXXX calls into macros for speed by Jay Fenlason.
  32.    Use -DHAVE_NETDB_H for rexec code, courtesy of Dan Kegel, srs!dan.  */
  33.  
  34. #include <stdio.h>
  35. #include <sys/types.h>
  36. #include <signal.h>
  37.  
  38. #ifdef HAVE_SYS_MTIO_H
  39. #include <sys/ioctl.h>
  40. #include <sys/mtio.h>
  41. #endif
  42.  
  43. #ifdef HAVE_NETDB_H
  44. #include <netdb.h>
  45. #endif
  46.  
  47. #include <errno.h>
  48. #include <setjmp.h>
  49. #include <sys/stat.h>
  50.  
  51. #ifndef errno
  52. extern int errno;
  53. #endif
  54.  
  55. #ifdef HAVE_UNISTD_H
  56. #include <unistd.h>
  57. #endif
  58. #ifdef STDC_HEADERS
  59. #include <string.h>
  60. #include <stdlib.h>
  61. #endif
  62.  
  63. /* Maximum size of a fully qualified host name.  */
  64. #define MAXHOSTLEN 257
  65.  
  66. /* Size of buffers for reading and writing commands to rmt.
  67.    (An arbitrary limit.)  */
  68. #define CMDBUFSIZE 64
  69.  
  70. #ifndef RETSIGTYPE
  71. #define RETSIGTYPE void
  72. #endif
  73.  
  74. /* Maximum number of simultaneous remote tape connections.
  75.    (Another arbitrary limit.)  */
  76. #define MAXUNIT    4
  77.  
  78. /* Return the parent's read side of remote tape connection FILDES.  */
  79. #define READ(fildes) (from_rmt[fildes][0])
  80.  
  81. /* Return the parent's write side of remote tape connection FILDES.  */
  82. #define WRITE(fildes) (to_rmt[fildes][1])
  83.  
  84. /* The pipes for receiving data from remote tape drives.  */
  85. static int from_rmt[MAXUNIT][2] =
  86. {-1, -1, -1, -1, -1, -1, -1, -1};
  87.  
  88. /* The pipes for sending data to remote tape drives.  */
  89. static int to_rmt[MAXUNIT][2] =
  90. {-1, -1, -1, -1, -1, -1, -1, -1};
  91.  
  92. /* Temporary variable used by macros in rmt.h.  */
  93. char *__rmt_path;
  94.  
  95. /* Close remote tape connection FILDES.  */
  96.  
  97. static void
  98. _rmt_shutdown (fildes)
  99.      int fildes;
  100. {
  101.   close (READ (fildes));
  102.   close (WRITE (fildes));
  103.   READ (fildes) = -1;
  104.   WRITE (fildes) = -1;
  105. }
  106.  
  107. /* Attempt to perform the remote tape command specified in BUF
  108.    on remote tape connection FILDES.
  109.    Return 0 if successful, -1 on error.  */
  110.  
  111. static int
  112. command (fildes, buf)
  113.      int fildes;
  114.      char *buf;
  115. {
  116.   register int buflen;
  117.   RETSIGTYPE (*pipe_handler) ();
  118.  
  119.   /* Save the current pipe handler and try to make the request.  */
  120.  
  121.   pipe_handler = signal (SIGPIPE, SIG_IGN);
  122.   buflen = strlen (buf);
  123.   if (write (WRITE (fildes), buf, buflen) == buflen)
  124.     {
  125.       signal (SIGPIPE, pipe_handler);
  126.       return 0;
  127.     }
  128.  
  129.   /* Something went wrong.  Close down and go home.  */
  130.  
  131.   signal (SIGPIPE, pipe_handler);
  132.   _rmt_shutdown (fildes);
  133.   errno = EIO;
  134.   return -1;
  135. }
  136.  
  137. /* Read and return the status from remote tape connection FILDES.
  138.    If an error occurred, return -1 and set errno.  */
  139.  
  140. static int
  141. status (fildes)
  142.      int fildes;
  143. {
  144.   int i;
  145.   char c, *cp;
  146.   char buffer[CMDBUFSIZE];
  147.  
  148.   /* Read the reply command line.  */
  149.  
  150.   for (i = 0, cp = buffer; i < CMDBUFSIZE; i++, cp++)
  151.     {
  152.       if (read (READ (fildes), cp, 1) != 1)
  153.     {
  154.       _rmt_shutdown (fildes);
  155.       errno = EIO;
  156.       return -1;
  157.     }
  158.       if (*cp == '\n')
  159.     {
  160.       *cp = '\0';
  161.       break;
  162.     }
  163.     }
  164.  
  165.   if (i == CMDBUFSIZE)
  166.     {
  167.       _rmt_shutdown (fildes);
  168.       errno = EIO;
  169.       return -1;
  170.     }
  171.  
  172.   /* Check the return status.  */
  173.  
  174.   for (cp = buffer; *cp; cp++)
  175.     if (*cp != ' ')
  176.       break;
  177.  
  178.   if (*cp == 'E' || *cp == 'F')
  179.     {
  180.       errno = atoi (cp + 1);
  181.       /* Skip the error message line.  */
  182.       while (read (READ (fildes), &c, 1) == 1)
  183.     if (c == '\n')
  184.       break;
  185.  
  186.       if (*cp == 'F')
  187.     _rmt_shutdown (fildes);
  188.  
  189.       return -1;
  190.     }
  191.  
  192.   /* Check for mis-synced pipes. */
  193.  
  194.   if (*cp != 'A')
  195.     {
  196.       _rmt_shutdown (fildes);
  197.       errno = EIO;
  198.       return -1;
  199.     }
  200.  
  201.   /* Got an `A' (success) response.  */
  202.   return atoi (cp + 1);
  203. }
  204.  
  205. #ifdef HAVE_NETDB_H
  206. /* Execute /etc/rmt as user USER on remote system HOST using rexec.
  207.    Return a file descriptor of a bidirectional socket for stdin and stdout.
  208.    If USER is NULL, or an empty string, use the current username.
  209.  
  210.    By default, this code is not used, since it requires that
  211.    the user have a .netrc file in his/her home directory, or that the
  212.    application designer be willing to have rexec prompt for login and
  213.    password info.  This may be unacceptable, and .rhosts files for use
  214.    with rsh are much more common on BSD systems.  */
  215.  
  216. static int
  217. _rmt_rexec (host, user)
  218.      char *host;
  219.      char *user;
  220. {
  221.   struct servent *rexecserv;
  222.   int save_stdin = dup (fileno (stdin));
  223.   int save_stdout = dup (fileno (stdout));
  224.   int tape_fd;            /* Return value. */
  225.  
  226.   /* When using cpio -o < filename, stdin is no longer the tty.
  227.      But the rexec subroutine reads the login and the passwd on stdin,
  228.      to allow remote execution of the command.
  229.      So, reopen stdin and stdout on /dev/tty before the rexec and
  230.      give them back their original value after.  */
  231.   if (freopen ("/dev/tty", "r", stdin) == NULL)
  232.     freopen ("/dev/null", "r", stdin);
  233.   if (freopen ("/dev/tty", "w", stdout) == NULL)
  234.     freopen ("/dev/null", "w", stdout);
  235.  
  236.   rexecserv = getservbyname ("exec", "tcp");
  237.   if (NULL == rexecserv)
  238.     {
  239.       fprintf (stderr, "exec/tcp: service not available");
  240.       exit (1);
  241.     }
  242.   if (user != NULL && *user == '\0')
  243.     user = NULL;
  244.   tape_fd = rexec (&host, rexecserv->s_port, user, NULL,
  245.            "/etc/rmt", (int *) NULL);
  246.   fclose (stdin);
  247.   fdopen (save_stdin, "r");
  248.   fclose (stdout);
  249.   fdopen (save_stdout, "w");
  250.  
  251.   return tape_fd;
  252. }
  253.  
  254. #endif /* HAVE_NETDB_H */
  255.  
  256. /* Open a magtape device on the system specified in PATH, as the given user.
  257.    PATH has the form `[user@]system:/dev/????'.
  258.    If COMPAT is defined, it can also have the form `system[.user]:/dev/????'.
  259.  
  260.    OFLAG is O_RDONLY, O_WRONLY, etc.
  261.    MODE is ignored; 0666 is always used.
  262.  
  263.    If successful, return the remote tape pipe number plus BIAS.
  264.    On error, return -1.  */
  265.  
  266. int
  267. __rmt_open (path, oflag, mode, bias)
  268.      char *path;
  269.      int oflag;
  270.      int mode;
  271.      int bias;
  272. {
  273.   int i, rc;
  274.   char buffer[CMDBUFSIZE];    /* Command buffer.  */
  275.   char system[MAXHOSTLEN];    /* The remote host name.  */
  276.   char device[CMDBUFSIZE];    /* The remote device name.  */
  277.   char login[CMDBUFSIZE];    /* The remote user name.  */
  278.   char *sys, *dev, *user;    /* For copying into the above buffers.  */
  279.  
  280.   sys = system;
  281.   dev = device;
  282.   user = login;
  283.  
  284.   /* Find an unused pair of file descriptors.  */
  285.  
  286.   for (i = 0; i < MAXUNIT; i++)
  287.     if (READ (i) == -1 && WRITE (i) == -1)
  288.       break;
  289.  
  290.   if (i == MAXUNIT)
  291.     {
  292.       errno = EMFILE;
  293.       return -1;
  294.     }
  295.  
  296.   /* Pull apart the system and device, and optional user.
  297.      Don't munge the original string.  */
  298.  
  299.   while (*path != '@'
  300. #ifdef COMPAT
  301.      && *path != '.'
  302. #endif
  303.      && *path != ':')
  304.     {
  305.       *sys++ = *path++;
  306.     }
  307.   *sys = '\0';
  308.   path++;
  309.  
  310.   if (*(path - 1) == '@')
  311.     {
  312.       /* Saw user part of user@host.  Start over. */
  313.       strcpy (user, system);
  314.       sys = system;
  315.       while (*path != ':')
  316.     {
  317.       *sys++ = *path++;
  318.     }
  319.       *sys = '\0';
  320.       path++;
  321.     }
  322. #ifdef COMPAT
  323.   else if (*(path - 1) == '.')
  324.     {
  325.       while (*path != ':')
  326.     {
  327.       *user++ = *path++;
  328.     }
  329.       *user = '\0';
  330.       path++;
  331.     }
  332. #endif
  333.   else
  334.     *user = '\0';
  335.  
  336.   while (*path)
  337.     {
  338.       *dev++ = *path++;
  339.     }
  340.   *dev = '\0';
  341.  
  342. #ifdef HAVE_NETDB_H
  343.   /* Execute the remote command using rexec.  */
  344.   READ (i) = WRITE (i) = _rmt_rexec (system, login);
  345.   if (READ (i) < 0)
  346.     return -1;
  347. #else /* !HAVE_NETDB_H */
  348.   /* Set up the pipes for the `rsh' command, and fork.  */
  349.  
  350.   if (pipe (to_rmt[i]) == -1 || pipe (from_rmt[i]) == -1)
  351.     return -1;
  352.  
  353.   rc = fork ();
  354.   if (rc == -1)
  355.     return -1;
  356.  
  357.   if (rc == 0)
  358.     {
  359.       /* Child.  */
  360.       close (0);
  361.       dup (to_rmt[i][0]);
  362.       close (to_rmt[i][0]);
  363.       close (to_rmt[i][1]);
  364.  
  365.       close (1);
  366.       dup (from_rmt[i][1]);
  367.       close (from_rmt[i][0]);
  368.       close (from_rmt[i][1]);
  369.  
  370.       setuid (getuid ());
  371.       setgid (getgid ());
  372.  
  373.       if (*login)
  374.     {
  375.       execl ("/usr/ucb/rsh", "rsh", system, "-l", login,
  376.          "/etc/rmt", (char *) 0);
  377.       execl ("/usr/bin/remsh", "remsh", system, "-l", login,
  378.          "/etc/rmt", (char *) 0);
  379.       execl ("/usr/bin/rsh", "rsh", system, "-l", login,
  380.          "/etc/rmt", (char *) 0);
  381.       execl ("/usr/bsd/rsh", "rsh", system, "-l", login,
  382.          "/etc/rmt", (char *) 0);
  383.       execl ("/usr/bin/nsh", "nsh", system, "-l", login,
  384.          "/etc/rmt", (char *) 0);
  385.     }
  386.       else
  387.     {
  388.       execl ("/usr/ucb/rsh", "rsh", system,
  389.          "/etc/rmt", (char *) 0);
  390.       execl ("/usr/bin/remsh", "remsh", system,
  391.          "/etc/rmt", (char *) 0);
  392.       execl ("/usr/bin/rsh", "rsh", system,
  393.          "/etc/rmt", (char *) 0);
  394.       execl ("/usr/bsd/rsh", "rsh", system,
  395.          "/etc/rmt", (char *) 0);
  396.       execl ("/usr/bin/nsh", "nsh", system,
  397.          "/etc/rmt", (char *) 0);
  398.     }
  399.  
  400.       /* Bad problems if we get here.  */
  401.  
  402.       perror ("cannot execute remote shell");
  403.       _exit (1);
  404.     }
  405.  
  406.   /* Parent.  */
  407.   close (to_rmt[i][0]);
  408.   close (from_rmt[i][1]);
  409. #endif /* !HAVE_NETDB_H */
  410.  
  411.   /* Attempt to open the tape device.  */
  412.  
  413.   sprintf (buffer, "O%s\n%d\n", device, oflag);
  414.   if (command (i, buffer) == -1 || status (i) == -1)
  415.     return -1;
  416.  
  417.   return i + bias;
  418. }
  419.  
  420. /* Close remote tape connection FILDES and shut down.
  421.    Return 0 if successful, -1 on error.  */
  422.  
  423. int
  424. __rmt_close (fildes)
  425.      int fildes;
  426. {
  427.   int rc;
  428.  
  429.   if (command (fildes, "C\n") == -1)
  430.     return -1;
  431.  
  432.   rc = status (fildes);
  433.   _rmt_shutdown (fildes);
  434.   return rc;
  435. }
  436.  
  437. /* Read up to NBYTE bytes into BUF from remote tape connection FILDES.
  438.    Return the number of bytes read on success, -1 on error.  */
  439.  
  440. int
  441. __rmt_read (fildes, buf, nbyte)
  442.      int fildes;
  443.      char *buf;
  444.      unsigned int nbyte;
  445. {
  446.   int rc, i;
  447.   char buffer[CMDBUFSIZE];
  448.  
  449.   sprintf (buffer, "R%d\n", nbyte);
  450.   if (command (fildes, buffer) == -1 || (rc = status (fildes)) == -1)
  451.     return -1;
  452.  
  453.   for (i = 0; i < rc; i += nbyte, buf += nbyte)
  454.     {
  455.       nbyte = read (READ (fildes), buf, rc - i);
  456.       if (nbyte <= 0)
  457.     {
  458.       _rmt_shutdown (fildes);
  459.       errno = EIO;
  460.       return -1;
  461.     }
  462.     }
  463.  
  464.   return rc;
  465. }
  466.  
  467. /* Write NBYTE bytes from BUF to remote tape connection FILDES.
  468.    Return the number of bytes written on success, -1 on error.  */
  469.  
  470. int
  471. __rmt_write (fildes, buf, nbyte)
  472.      int fildes;
  473.      char *buf;
  474.      unsigned int nbyte;
  475. {
  476.   char buffer[CMDBUFSIZE];
  477.   RETSIGTYPE (*pipe_handler) ();
  478.  
  479.   sprintf (buffer, "W%d\n", nbyte);
  480.   if (command (fildes, buffer) == -1)
  481.     return -1;
  482.  
  483.   pipe_handler = signal (SIGPIPE, SIG_IGN);
  484.   if (write (WRITE (fildes), buf, nbyte) == nbyte)
  485.     {
  486.       signal (SIGPIPE, pipe_handler);
  487.       return status (fildes);
  488.     }
  489.  
  490.   /* Write error.  */
  491.   signal (SIGPIPE, pipe_handler);
  492.   _rmt_shutdown (fildes);
  493.   errno = EIO;
  494.   return -1;
  495. }
  496.  
  497. /* Perform an imitation lseek operation on remote tape connection FILDES.
  498.    Return the new file offset if successful, -1 if on error.  */
  499.  
  500. long
  501. __rmt_lseek (fildes, offset, whence)
  502.      int fildes;
  503.      long offset;
  504.      int whence;
  505. {
  506.   char buffer[CMDBUFSIZE];
  507.  
  508.   sprintf (buffer, "L%ld\n%d\n", offset, whence);
  509.   if (command (fildes, buffer) == -1)
  510.     return -1;
  511.  
  512.   return status (fildes);
  513. }
  514.  
  515. /* Perform a raw tape operation on remote tape connection FILDES.
  516.    Return the results of the ioctl, or -1 on error.  */
  517.  
  518. #ifdef MTIOCTOP
  519. int
  520. __rmt_ioctl (fildes, op, arg)
  521.      int fildes, op;
  522.      char *arg;
  523. {
  524.   char c;
  525.   int rc, cnt;
  526.   char buffer[CMDBUFSIZE];
  527.  
  528.   switch (op)
  529.     {
  530.     default:
  531.       errno = EINVAL;
  532.       return -1;
  533.  
  534.     case MTIOCTOP:
  535.       /* MTIOCTOP is the easy one.  Nothing is transfered in binary.  */
  536.       sprintf (buffer, "I%d\n%d\n", ((struct mtop *) arg)->mt_op,
  537.            ((struct mtop *) arg)->mt_count);
  538.       if (command (fildes, buffer) == -1)
  539.     return -1;
  540.       return status (fildes);    /* Return the count.  */
  541.  
  542.     case MTIOCGET:
  543.       /* Grab the status and read it directly into the structure.
  544.      This assumes that the status buffer is not padded
  545.      and that 2 shorts fit in a long without any word
  546.      alignment problems; i.e., the whole struct is contiguous.
  547.      NOTE - this is probably NOT a good assumption.  */
  548.  
  549.       if (command (fildes, "S") == -1 || (rc = status (fildes)) == -1)
  550.     return -1;
  551.  
  552.       for (; rc > 0; rc -= cnt, arg += cnt)
  553.     {
  554.       cnt = read (READ (fildes), arg, rc);
  555.       if (cnt <= 0)
  556.         {
  557.           _rmt_shutdown (fildes);
  558.           errno = EIO;
  559.           return -1;
  560.         }
  561.     }
  562.  
  563.       /* Check for byte position.  mt_type is a small integer field
  564.      (normally) so we will check its magnitude.  If it is larger than
  565.      256, we will assume that the bytes are swapped and go through
  566.      and reverse all the bytes.  */
  567.  
  568.       if (((struct mtget *) arg)->mt_type < 256)
  569.     return 0;
  570.  
  571.       for (cnt = 0; cnt < rc; cnt += 2)
  572.     {
  573.       c = arg[cnt];
  574.       arg[cnt] = arg[cnt + 1];
  575.       arg[cnt + 1] = c;
  576.     }
  577.  
  578.       return 0;
  579.     }
  580. }
  581.  
  582. #endif
  583.